home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 21 / CU Amiga Magazine's Super CD-ROM 21 (1998)(EMAP Images)(GB)[!][issue 1998-04].iso / CUCD / Games / ADoom / ADoom_src / r_draw.c < prev    next >
C/C++ Source or Header  |  1998-01-31  |  24KB  |  1,075 lines
  1. // Emacs style mode select   -*- C++ -*- 
  2. //-----------------------------------------------------------------------------
  3. //
  4. // $Id:$
  5. //
  6. // Copyright (C) 1993-1996 by id Software, Inc.
  7. //
  8. // This source is available for distribution and/or modification
  9. // only under the terms of the DOOM Source Code License as
  10. // published by id Software. All rights reserved.
  11. //
  12. // The source is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
  15. // for more details.
  16. //
  17. // $Log:$
  18. //
  19. // DESCRIPTION:
  20. //    The actual span/column drawing functions.
  21. //    Here find the main potential for optimization,
  22. //     e.g. inline assembly, different algorithms.
  23. //
  24. //-----------------------------------------------------------------------------
  25.  
  26.  
  27. static const char
  28. rcsid[] = "$Id: r_draw.c,v 1.4 1997/02/03 16:47:55 b1 Exp $";
  29.  
  30.  
  31. #include "doomdef.h"
  32.  
  33. #include "i_system.h"
  34. #include "z_zone.h"
  35. #include "w_wad.h"
  36.  
  37. #include "r_local.h"
  38.  
  39. // Needs access to LFB (guess what).
  40. #include "v_video.h"
  41.  
  42. // State.
  43. #include "doomstat.h"
  44.  
  45.  
  46. // ?
  47. #define MAXWIDTH            1120
  48. #define MAXHEIGHT            832
  49.  
  50. // status bar height at bottom of screen
  51. #define SBARHEIGHT        32
  52.  
  53. //
  54. // All drawing to the view buffer is accomplished in this file.
  55. // The other refresh files only know about ccordinates,
  56. //  not the architecture of the frame buffer.
  57. // Conveniently, the frame buffer is a linear one,
  58. //  and we need only the base address,
  59. //  and the total size == width*height*depth/8.,
  60. //
  61.  
  62.  
  63. byte*        viewimage; 
  64. int        viewwidth;
  65. int        scaledviewwidth;
  66. int        viewheight;
  67. int        viewwindowx;
  68. int        viewwindowy; 
  69. byte*        ylookup[MAXHEIGHT]; 
  70. byte*        ylookup2[MAXHEIGHT]; 
  71. int        columnofs[MAXWIDTH]; 
  72.  
  73. // Color tables for different players,
  74. //  translate a limited part to another
  75. //  (color ramps used for  suit colors).
  76. //
  77. FAR byte    translations[3][256];    
  78.  
  79.  
  80.  
  81.  
  82. //
  83. // R_DrawColumn
  84. // Source is the top of the column to scale.
  85. //
  86. lighttable_t*        dc_colormap; 
  87. int            dc_x; 
  88. int            dc_yl; 
  89. int            dc_yh; 
  90. fixed_t            dc_iscale; 
  91. fixed_t            dc_texturemid;
  92.  
  93. // first pixel in a column (possibly virtual) 
  94. byte*            dc_source;        
  95.  
  96. // just for profiling 
  97. int            dccount;
  98.  
  99. //
  100. // A column is a vertical slice/span from a wall texture that,
  101. //  given the DOOM style restrictions on the view orientation,
  102. //  will always have constant z depth.
  103. // Thus a special case loop for very fast rendering can
  104. //  be used. It has also been used with Wolfenstein 3D.
  105. // 
  106. // UNUSED.
  107. #ifndef AMIGA
  108. void R_DrawColumn (void) 
  109. { 
  110.     int            count; 
  111.     byte*        dest; 
  112.     fixed_t        frac;
  113.     fixed_t        fracstep;     
  114.  
  115.     count = dc_yh - dc_yl; 
  116.  
  117.     // Zero length, column does not exceed a pixel.
  118.     if (count < 0) 
  119.     return; 
  120.                  
  121. #ifdef RANGECHECK 
  122.     if ((unsigned)dc_x >= SCREENWIDTH
  123.     || dc_yl < 0
  124.     || dc_yh >= SCREENHEIGHT) 
  125.     I_Error ("R_DrawColumn: %i to %i at %i", dc_yl, dc_yh, dc_x); 
  126. #endif 
  127.  
  128.     // Framebuffer destination address.
  129.     // Use ylookup LUT to avoid multiply with ScreenWidth.
  130.     // Use columnofs LUT for subwindows? 
  131.     dest = ylookup[dc_yl] + columnofs[dc_x];  
  132.  
  133.     // Determine scaling,
  134.     //  which is the only mapping to be done.
  135.     fracstep = dc_iscale; 
  136.     frac = dc_texturemid + (dc_yl-centery)*fracstep; 
  137.  
  138.     // Inner loop that does the actual texture mapping,
  139.     //  e.g. a DDA-lile scaling.
  140.     // This is as fast as it gets.
  141.     do 
  142.     {
  143.     // Re-map color indices from wall texture column
  144.     //  using a lighting/special effects LUT.
  145.     *dest = dc_colormap[dc_source[(frac>>FRACBITS)&127]];
  146.     
  147.     dest += SCREENWIDTH; 
  148.     frac += fracstep;
  149.     
  150.     } while (count--); 
  151. } 
  152. #endif
  153.  
  154.  
  155.  
  156. // UNUSED.
  157. // Loop unrolled.
  158. #if 0
  159. void R_DrawColumn (void) 
  160. { 
  161.     int            count; 
  162.     byte*        source;
  163.     byte*        dest;
  164.     byte*        colormap;
  165.     
  166.     unsigned        frac;
  167.     unsigned        fracstep;
  168.     unsigned        fracstep2;
  169.     unsigned        fracstep3;
  170.     unsigned        fracstep4;     
  171.  
  172.     count = dc_yh - dc_yl + 1; 
  173.  
  174.     source = dc_source;
  175.     colormap = dc_colormap;         
  176.     dest = ylookup[dc_yl] + columnofs[dc_x];  
  177.      
  178.     fracstep = dc_iscale<<9; 
  179.     frac = (dc_texturemid + (dc_yl-centery)*dc_iscale)<<9; 
  180.  
  181.     fracstep2 = fracstep+fracstep;
  182.     fracstep3 = fracstep2+fracstep;
  183.     fracstep4 = fracstep3+fracstep;
  184.     
  185.     while (count >= 8) 
  186.     { 
  187.     dest[0] = colormap[source[frac>>25]]; 
  188.     dest[SCREENWIDTH] = colormap[source[(frac+fracstep)>>25]]; 
  189.     dest[SCREENWIDTH*2] = colormap[source[(frac+fracstep2)>>25]]; 
  190.     dest[SCREENWIDTH*3] = colormap[source[(frac+fracstep3)>>25]];
  191.     
  192.     frac += fracstep4; 
  193.  
  194.     dest[SCREENWIDTH*4] = colormap[source[frac>>25]]; 
  195.     dest[SCREENWIDTH*5] = colormap[source[(frac+fracstep)>>25]]; 
  196.     dest[SCREENWIDTH*6] = colormap[source[(frac+fracstep2)>>25]]; 
  197.     dest[SCREENWIDTH*7] = colormap[source[(frac+fracstep3)>>25]]; 
  198.  
  199.     frac += fracstep4; 
  200.     dest += SCREENWIDTH*8; 
  201.     count -= 8;
  202.     } 
  203.     
  204.     while (count > 0)
  205.     { 
  206.     *dest = colormap[source[frac>>25]]; 
  207.     dest += SCREENWIDTH; 
  208.     frac += fracstep; 
  209.     count--;
  210.     } 
  211. }
  212. #endif
  213.  
  214.  
  215. #ifndef AMIGA
  216. void R_DrawColumnLow (void) 
  217. { 
  218.     int            count; 
  219.     byte*        dest; 
  220.     byte*        dest2;
  221.     fixed_t        frac;
  222.     fixed_t        fracstep;     
  223.  
  224.     count = dc_yh - dc_yl; 
  225.  
  226.     // Zero length.
  227.     if (count < 0) 
  228.     return; 
  229.                  
  230. #ifdef RANGECHECK 
  231.     if ((unsigned)dc_x >= SCREENWIDTH
  232.     || dc_yl < 0
  233.     || dc_yh >= SCREENHEIGHT)
  234.     {
  235.     
  236.     I_Error ("R_DrawColumn: %i to %i at %i", dc_yl, dc_yh, dc_x);
  237.     }
  238.     //    dccount++; 
  239. #endif 
  240.     // Blocky mode, need to multiply by 2.
  241.     dc_x <<= 1;
  242.     
  243.     dest = ylookup[dc_yl] + columnofs[dc_x];
  244.     dest2 = ylookup[dc_yl] + columnofs[dc_x+1];
  245.     
  246.     fracstep = dc_iscale; 
  247.     frac = dc_texturemid + (dc_yl-centery)*fracstep;
  248.     
  249.     do 
  250.     {
  251.     // Hack. Does not work corretly.
  252.     *dest2 = *dest = dc_colormap[dc_source[(frac>>FRACBITS)&127]];
  253.     dest += SCREENWIDTH;
  254.     dest2 += SCREENWIDTH;
  255.     frac += fracstep; 
  256.  
  257.     } while (count--);
  258. }
  259. #endif
  260.  
  261.  
  262. //
  263. // Spectre/Invisibility.
  264. //
  265. #ifndef AMIGA
  266. #define FUZZTABLE       50 
  267. #else
  268. #define FUZZTABLE       250
  269. #endif
  270. #define FUZZOFF    (SCREENWIDTH)
  271.  
  272.  
  273. int    fuzzoffset[FUZZTABLE] =
  274. {
  275.     FUZZOFF,-FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  276.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  277.     FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,
  278.     FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  279.     FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,
  280.     FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,
  281.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF 
  282. #ifdef AMIGA
  283.     ,FUZZOFF,-FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  284.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  285.     FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,
  286.     FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  287.     FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,
  288.     FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,
  289.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,
  290.     FUZZOFF,-FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  291.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  292.     FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,
  293.     FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  294.     FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,
  295.     FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,
  296.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,
  297.     FUZZOFF,-FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  298.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  299.     FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,
  300.     FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  301.     FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,
  302.     FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,
  303.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,
  304.     FUZZOFF,-FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  305.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  306.     FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,
  307.     FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,
  308.     FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,
  309.     FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,
  310.     FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF,FUZZOFF,-FUZZOFF,FUZZOFF
  311. #endif
  312. }; 
  313.  
  314.  
  315. int    fuzzpos = 0; 
  316.  
  317.  
  318. #ifndef AMIGA
  319.  
  320. //
  321. // Framebuffer postprocessing.
  322. // Creates a fuzzy image by copying pixels
  323. //  from adjacent ones to left and right.
  324. // Used with an all black colormap, this
  325. //  could create the SHADOW effect,
  326. //  i.e. spectres and invisible players.
  327. //
  328. void R_DrawFuzzColumn (void) 
  329. { 
  330.     int            count; 
  331.     byte*        dest; 
  332.     fixed_t        frac;
  333.     fixed_t        fracstep;     
  334.  
  335.     // Adjust borders. Low... 
  336.     if (!dc_yl) 
  337.     dc_yl = 1;
  338.  
  339.     // .. and high.
  340.     if (dc_yh == viewheight-1) 
  341.     dc_yh = viewheight - 2; 
  342.          
  343.     count = dc_yh - dc_yl; 
  344.  
  345.     // Zero length.
  346.     if (count < 0) 
  347.     return; 
  348.  
  349.     
  350. #ifdef RANGECHECK 
  351.     if ((unsigned)dc_x >= SCREENWIDTH
  352.     || dc_yl < 0 || dc_yh >= SCREENHEIGHT)
  353.     {
  354.     I_Error ("R_DrawFuzzColumn: %i to %i at %i",
  355.          dc_yl, dc_yh, dc_x);
  356.     }
  357. #endif
  358.  
  359.  
  360.     // Keep till detailshift bug in blocky mode fixed,
  361.     //  or blocky mode removed.
  362.     /* WATCOM code 
  363.     if (detailshift)
  364.     {
  365.     if (dc_x & 1)
  366.     {
  367.         outpw (GC_INDEX,GC_READMAP+(2<<8) ); 
  368.         outp (SC_INDEX+1,12); 
  369.     }
  370.     else
  371.     {
  372.         outpw (GC_INDEX,GC_READMAP); 
  373.         outp (SC_INDEX+1,3); 
  374.     }
  375.     dest = destview + dc_yl*80 + (dc_x>>1); 
  376.     }
  377.     else
  378.     {
  379.     outpw (GC_INDEX,GC_READMAP+((dc_x&3)<<8) ); 
  380.     outp (SC_INDEX+1,1<<(dc_x&3)); 
  381.     dest = destview + dc_yl*80 + (dc_x>>2); 
  382.     }*/
  383.  
  384.     
  385.     // Does not work with blocky mode.
  386.     dest = ylookup[dc_yl] + columnofs[dc_x];
  387.  
  388.     // Looks familiar.
  389.     fracstep = dc_iscale; 
  390.     frac = dc_texturemid + (dc_yl-centery)*fracstep; 
  391.  
  392.     // Looks like an attempt at dithering,
  393.     //  using the colormap #6 (of 0-31, a bit
  394.     //  brighter than average).
  395.     do 
  396.     {
  397.     // Lookup framebuffer, and retrieve
  398.     //  a pixel that is either one column
  399.     //  left or right of the current one.
  400.     // Add index from colormap to index.
  401.     *dest = colormaps[6*256+dest[fuzzoffset[fuzzpos]]]; 
  402.  
  403.     // Clamp table lookup index.
  404.     if (++fuzzpos == FUZZTABLE) 
  405.         fuzzpos = 0;
  406.     
  407.     dest += SCREENWIDTH;
  408.  
  409.     frac += fracstep; 
  410.     } while (count--); 
  411. } 
  412. #endif
  413.  
  414.   
  415.  
  416.  
  417. #ifndef AMIGA
  418.  
  419. //
  420. // Framebuffer postprocessing.
  421. // Creates a fuzzy image by copying pixels
  422. //  from adjacent ones to left and right.
  423. // Used with an all black colormap, this
  424. //  could create the SHADOW effect,
  425. //  i.e. spectres and invisible players.
  426. //
  427. void R_DrawFuzzColumnLow (void) 
  428. { 
  429.     int            count; 
  430.     byte*        dest; 
  431.     byte*        dest2; 
  432.     fixed_t        frac;
  433.     fixed_t        fracstep;     
  434.  
  435.     // Adjust borders. Low... 
  436.     if (!dc_yl) 
  437.     dc_yl = 1;
  438.  
  439.     // .. and high.
  440.     if (dc_yh == viewheight-1) 
  441.     dc_yh = viewheight - 2; 
  442.          
  443.     count = dc_yh - dc_yl; 
  444.  
  445.     // Zero length.
  446.     if (count < 0) 
  447.     return; 
  448.  
  449.     
  450. #ifdef RANGECHECK 
  451.     if (((unsigned)dc_x << 1) >= SCREENWIDTH
  452.     || dc_yl < 0 || dc_yh >= SCREENHEIGHT)
  453.     {
  454.     I_Error ("R_DrawFuzzColumn: %i to %i at %i",
  455.          dc_yl, dc_yh, dc_x);
  456.     }
  457. #endif
  458.  
  459.  
  460.     // Does not work with blocky mode.
  461.     dest = ylookup[dc_yl] + columnofs[dc_x << 1];
  462.     dest2 = ylookup[dc_yl] + columnofs[(dc_x << 1) + 1];
  463.  
  464.     // Looks familiar.
  465.     fracstep = dc_iscale;
  466.     frac = dc_texturemid + (dc_yl-centery)*fracstep;
  467.  
  468.     // Looks like an attempt at dithering,
  469.     //  using the colormap #6 (of 0-31, a bit
  470.     //  brighter than average).
  471.     do 
  472.     {
  473.     // Lookup framebuffer, and retrieve
  474.     //  a pixel that is either one column
  475.     //  left or right of the current one.
  476.     // Add index from colormap to index.
  477.     *dest2 = *dest = colormaps[6*256+dest[fuzzoffset[fuzzpos]]];
  478.  
  479.     // Clamp table lookup index.
  480.     if (++fuzzpos == FUZZTABLE)
  481.         fuzzpos = 0;
  482.  
  483.     dest += SCREENWIDTH;
  484.     dest2 += SCREENWIDTH;
  485.  
  486.     frac += fracstep;
  487.     } while (count--);
  488. }
  489. #endif
  490.  
  491.   
  492.  
  493.  
  494. //
  495. // R_DrawTranslatedColumn
  496. // Used to draw player sprites
  497. //  with the green colorramp mapped to others.
  498. // Could be used with different translation
  499. //  tables, e.g. the lighter colored version
  500. //  of the BaronOfHell, the HellKnight, uses
  501. //  identical sprites, kinda brightened up.
  502. //
  503. byte*    dc_translation;
  504. byte*    translationtables;
  505.  
  506. //#ifndef AMIGA
  507.  
  508. void R_DrawTranslatedColumn (void) 
  509. { 
  510.     int            count; 
  511.     byte*        dest; 
  512.     fixed_t        frac;
  513.     fixed_t        fracstep;     
  514.  
  515.     count = dc_yh - dc_yl; 
  516.     if (count < 0) 
  517.     return; 
  518.                  
  519. #ifdef RANGECHECK 
  520.     if ((unsigned)dc_x >= SCREENWIDTH
  521.     || dc_yl < 0
  522.     || dc_yh >= SCREENHEIGHT)
  523.     {
  524.     I_Error ( "R_DrawColumn: %i to %i at %i",
  525.           dc_yl, dc_yh, dc_x);
  526.     }
  527.     
  528. #endif 
  529.  
  530.  
  531.     // WATCOM VGA specific.
  532.     /* Keep for fixing.
  533.     if (detailshift)
  534.     {
  535.     if (dc_x & 1)
  536.         outp (SC_INDEX+1,12); 
  537.     else
  538.         outp (SC_INDEX+1,3);
  539.     
  540.     dest = destview + dc_yl*80 + (dc_x>>1); 
  541.     }
  542.     else
  543.     {
  544.     outp (SC_INDEX+1,1<<(dc_x&3)); 
  545.  
  546.     dest = destview + dc_yl*80 + (dc_x>>2); 
  547.     }*/
  548.  
  549.     
  550.     // FIXME. As above.
  551.     dest = ylookup[dc_yl] + columnofs[dc_x]; 
  552.  
  553.     // Looks familiar.
  554.     fracstep = dc_iscale; 
  555.     frac = dc_texturemid + (dc_yl-centery)*fracstep; 
  556.  
  557.     // Here we do an additional index re-mapping.
  558.     do 
  559.     {
  560.     // Translation tables are used
  561.     //  to map certain colorramps to other ones,
  562.     //  used with PLAY sprites.
  563.     // Thus the "green" ramp of the player 0 sprite
  564.     //  is mapped to gray, red, black/indigo. 
  565.     *dest = dc_colormap[dc_translation[dc_source[frac>>FRACBITS]]];
  566.     dest += SCREENWIDTH;
  567.     
  568.     frac += fracstep; 
  569.     } while (count--); 
  570. } 
  571.  
  572. //#endif
  573.  
  574.  
  575.  
  576. //
  577. // R_DrawTranslatedColumn
  578. // Used to draw player sprites
  579. //  with the green colorramp mapped to others.
  580. // Could be used with different translation
  581. //  tables, e.g. the lighter colored version
  582. //  of the BaronOfHell, the HellKnight, uses
  583. //  identical sprites, kinda brightened up.
  584. //
  585. byte*    dc_translation;
  586. byte*    translationtables;
  587.  
  588. //#ifndef AMIGA
  589.  
  590. void R_DrawTranslatedColumnLow (void) 
  591. { 
  592.     int            count; 
  593.     byte*        dest; 
  594.     byte*        dest2;
  595.     fixed_t        frac;
  596.     fixed_t        fracstep;     
  597.  
  598.     count = dc_yh - dc_yl; 
  599.     if (count < 0) 
  600.     return; 
  601.                  
  602. #ifdef RANGECHECK 
  603.     if (((unsigned)dc_x << 1) >= SCREENWIDTH
  604.     || dc_yl < 0
  605.     || dc_yh >= SCREENHEIGHT)
  606.     {
  607.     I_Error ( "R_DrawColumn: %i to %i at %i",
  608.           dc_yl, dc_yh, dc_x);
  609.     }
  610.     
  611. #endif 
  612.  
  613.  
  614.     // FIXME. As above.
  615.     dest = ylookup[dc_yl] + columnofs[dc_x << 1]; 
  616.     dest2 = ylookup[dc_yl] + columnofs[(dc_x << 1) + 1];
  617.  
  618.     // Looks familiar.
  619.     fracstep = dc_iscale; 
  620.     frac = dc_texturemid + (dc_yl-centery)*fracstep; 
  621.  
  622.     // Here we do an additional index re-mapping.
  623.     do 
  624.     {
  625.     // Translation tables are used
  626.     //  to map certain colorramps to other ones,
  627.     //  used with PLAY sprites.
  628.     // Thus the "green" ramp of the player 0 sprite
  629.     //  is mapped to gray, red, black/indigo. 
  630.     *dest2 = *dest = dc_colormap[dc_translation[dc_source[frac>>FRACBITS]]];
  631.     dest += SCREENWIDTH;
  632.     dest2 += SCREENWIDTH;
  633.     
  634.     frac += fracstep; 
  635.     } while (count--); 
  636. } 
  637.  
  638. //#endif
  639.  
  640.  
  641.  
  642. //
  643. // R_InitTranslationTables
  644. // Creates the translation tables to map
  645. //  the green color ramp to gray, brown, red.
  646. // Assumes a given structure of the PLAYPAL.
  647. // Could be read from a lump instead.
  648. //
  649. void R_InitTranslationTables (void)
  650. {
  651.     int        i;
  652.     
  653.     translationtables = Z_Malloc (256*3+255, PU_STATIC, 0);
  654.     translationtables = (byte *)(( (int)translationtables + 255 )& ~255);
  655.     
  656.     // translate just the 16 green colors
  657.     for (i=0 ; i<256 ; i++)
  658.     {
  659.     if (i >= 0x70 && i<= 0x7f)
  660.     {
  661.         // map green ramp to gray, brown, red
  662.         translationtables[i] = 0x60 + (i&0xf);
  663.         translationtables [i+256] = 0x40 + (i&0xf);
  664.         translationtables [i+512] = 0x20 + (i&0xf);
  665.     }
  666.     else
  667.     {
  668.         // Keep all other colors as is.
  669.         translationtables[i] = translationtables[i+256] 
  670.         = translationtables[i+512] = i;
  671.     }
  672.     }
  673. }
  674.  
  675.  
  676.  
  677.  
  678. //
  679. // R_DrawSpan 
  680. // With DOOM style restrictions on view orientation,
  681. //  the floors and ceilings consist of horizontal slices
  682. //  or spans with constant z depth.
  683. // However, rotation around the world z axis is possible,
  684. //  thus this mapping, while simpler and faster than
  685. //  perspective correct texture mapping, has to traverse
  686. //  the texture at an angle in all but a few cases.
  687. // In consequence, flats are not stored by column (like walls),
  688. //  and the inner loop has to step in texture space u and v.
  689. //
  690. int            ds_y; 
  691. int            ds_x1; 
  692. int            ds_x2;
  693.  
  694. lighttable_t*        ds_colormap; 
  695.  
  696. fixed_t            ds_xfrac; 
  697. fixed_t            ds_yfrac; 
  698. fixed_t            ds_xstep; 
  699. fixed_t            ds_ystep;
  700.  
  701. // start of a 64*64 tile image 
  702. byte*            ds_source;    
  703.  
  704. // just for profiling
  705. int            dscount;
  706.  
  707.  
  708. //
  709. // Draws the actual span.
  710. // UNUSED.
  711. #ifndef AMIGA
  712. void R_DrawSpan (void) 
  713. { 
  714.     fixed_t        xfrac;
  715.     fixed_t        yfrac; 
  716.     byte*        dest; 
  717.     int            count;
  718.     int            spot; 
  719.      
  720. #ifdef RANGECHECK 
  721.     if (ds_x2 < ds_x1
  722.     || ds_x1<0
  723.     || ds_x2>=SCREENWIDTH  
  724.     || (unsigned)ds_y>SCREENHEIGHT)
  725.     {
  726.     I_Error( "R_DrawSpan: %i to %i at %i",
  727.          ds_x1,ds_x2,ds_y);
  728.     }
  729. //    dscount++; 
  730. #endif 
  731.  
  732.     
  733.     xfrac = ds_xfrac; 
  734.     yfrac = ds_yfrac; 
  735.      
  736.     dest = ylookup[ds_y] + columnofs[ds_x1];
  737.  
  738.     // We do not check for zero spans here?
  739.     count = ds_x2 - ds_x1; 
  740.  
  741.     do 
  742.     {
  743.     // Current texture index in u,v.
  744.     spot = ((yfrac>>(16-6))&(63*64)) + ((xfrac>>16)&63);
  745.  
  746.     // Lookup pixel from flat texture tile,
  747.     //  re-index using light/colormap.
  748.     *dest++ = ds_colormap[ds_source[spot]];
  749.  
  750.     // Next step in u,v.
  751.     xfrac += ds_xstep; 
  752.     yfrac += ds_ystep;
  753.     
  754.     } while (count--); 
  755. } 
  756. #endif
  757.  
  758.  
  759.  
  760. // UNUSED.
  761. // Loop unrolled by 4.
  762. #if 0
  763. void R_DrawSpan (void) 
  764. { 
  765.     unsigned    position, step;
  766.  
  767.     byte*    source;
  768.     byte*    colormap;
  769.     byte*    dest;
  770.     
  771.     unsigned    count;
  772.     usingned    spot; 
  773.     unsigned    value;
  774.     unsigned    temp;
  775.     unsigned    xtemp;
  776.     unsigned    ytemp;
  777.         
  778.     position = ((ds_xfrac<<10)&0xffff0000) | ((ds_yfrac>>6)&0xffff);
  779.     step = ((ds_xstep<<10)&0xffff0000) | ((ds_ystep>>6)&0xffff);
  780.         
  781.     source = ds_source;
  782.     colormap = ds_colormap;
  783.     dest = ylookup[ds_y] + columnofs[ds_x1];     
  784.     count = ds_x2 - ds_x1 + 1; 
  785.     
  786.     while (count >= 4) 
  787.     { 
  788.     ytemp = position>>4;
  789.     ytemp = ytemp & 4032;
  790.     xtemp = position>>26;
  791.     spot = xtemp | ytemp;
  792.     position += step;
  793.     dest[0] = colormap[source[spot]]; 
  794.  
  795.     ytemp = position>>4;
  796.     ytemp = ytemp & 4032;
  797.     xtemp = position>>26;
  798.     spot = xtemp | ytemp;
  799.     position += step;
  800.     dest[1] = colormap[source[spot]];
  801.     
  802.     ytemp = position>>4;
  803.     ytemp = ytemp & 4032;
  804.     xtemp = position>>26;
  805.     spot = xtemp | ytemp;
  806.     position += step;
  807.     dest[2] = colormap[source[spot]];
  808.     
  809.     ytemp = position>>4;
  810.     ytemp = ytemp & 4032;
  811.     xtemp = position>>26;
  812.     spot = xtemp | ytemp;
  813.     position += step;
  814.     dest[3] = colormap[source[spot]]; 
  815.         
  816.     count -= 4;
  817.     dest += 4;
  818.     } 
  819.     while (count > 0) 
  820.     { 
  821.     ytemp = position>>4;
  822.     ytemp = ytemp & 4032;
  823.     xtemp = position>>26;
  824.     spot = xtemp | ytemp;
  825.     position += step;
  826.     *dest++ = colormap[source[spot]]; 
  827.     count--;
  828.     } 
  829. } 
  830. #endif
  831.  
  832.  
  833. #ifndef AMIGA
  834. //
  835. // Again..
  836. //
  837. void R_DrawSpanLow (void) 
  838. { 
  839.     fixed_t        xfrac;
  840.     fixed_t        yfrac; 
  841.     byte*        dest; 
  842.     int            count;
  843.     int            spot; 
  844.      
  845. #ifdef RANGECHECK 
  846.     if (ds_x2 < ds_x1
  847.     || ds_x1<0
  848.     || ds_x2>=SCREENWIDTH  
  849.     || (unsigned)ds_y>SCREENHEIGHT)
  850.     {
  851.     I_Error( "R_DrawSpan: %i to %i at %i",
  852.          ds_x1,ds_x2,ds_y);
  853.     }
  854. //    dscount++; 
  855. #endif 
  856.      
  857.     xfrac = ds_xfrac; 
  858.     yfrac = ds_yfrac; 
  859.  
  860.     // Blocky mode, need to multiply by 2.
  861.     ds_x1 <<= 1;
  862.     ds_x2 <<= 1;
  863.     
  864.     dest = ylookup[ds_y] + columnofs[ds_x1];
  865.   
  866.     
  867.     count = ds_x2 - ds_x1; 
  868.     do 
  869.     { 
  870.     spot = ((yfrac>>(16-6))&(63*64)) + ((xfrac>>16)&63);
  871.     // Lowres/blocky mode does it twice,
  872.     //  while scale is adjusted appropriately.
  873.     *dest++ = ds_colormap[ds_source[spot]]; 
  874.     *dest++ = ds_colormap[ds_source[spot]];
  875.     
  876.     xfrac += ds_xstep; 
  877.     yfrac += ds_ystep; 
  878.  
  879.     } while (count--); 
  880. }
  881. #endif
  882.  
  883. //
  884. // R_InitBuffer 
  885. // Creats lookup tables that avoid
  886. //  multiplies and other hazzles
  887. //  for getting the framebuffer address
  888. //  of a pixel to draw.
  889. //
  890. void
  891. R_InitBuffer
  892. ( int        width,
  893.   int        height ) 
  894. { 
  895.     int        i; 
  896.  
  897.     // Handle resize,
  898.     //  e.g. smaller view windows
  899.     //  with border and/or status bar.
  900.     viewwindowx = (SCREENWIDTH-width) >> 1; 
  901.  
  902.     // Column offset. For windows.
  903.     for (i=0 ; i<width ; i++) 
  904.     columnofs[i] = viewwindowx + i;
  905.  
  906.     // Samw with base row offset.
  907.     if (width == SCREENWIDTH) 
  908.     viewwindowy = 0; 
  909.     else 
  910.     viewwindowy = (SCREENHEIGHT-SBARHEIGHT-height) >> 1; 
  911.  
  912.     // Preclaculate all row offsets.
  913.     for (i=0 ; i<height ; i++) {
  914.     ylookup[i] = screens[0] + (i+viewwindowy)*SCREENWIDTH; 
  915.         ylookup2[i] = ylookup[i] + viewwindowx;
  916.     }
  917. } 
  918.  
  919.  
  920.  
  921.  
  922. //
  923. // R_FillBackScreen
  924. // Fills the back screen with a pattern
  925. //  for variable screen sizes
  926. // Also draws a beveled edge.
  927. //
  928. void R_FillBackScreen (void) 
  929. { 
  930.     byte*    src;
  931.     byte*    dest; 
  932.     int        x;
  933.     int        y; 
  934.     patch_t*    patch;
  935.  
  936.     // DOOM border patch.
  937.     char    name1[] = "FLOOR7_2";
  938.  
  939.     // DOOM II border patch.
  940.     char    name2[] = "GRNROCK";    
  941.  
  942.     char*    name;
  943.     
  944.     if (scaledviewwidth == 320)
  945.     return;
  946.     
  947.     if ( gamemode == commercial)
  948.     name = name2;
  949.     else
  950.     name = name1;
  951.     
  952.     src = W_CacheLumpName (name, PU_CACHE); 
  953.     dest = screens[1]; 
  954.      
  955.     for (y=0 ; y<SCREENHEIGHT-SBARHEIGHT ; y++) 
  956.     { 
  957.     for (x=0 ; x<SCREENWIDTH/64 ; x++) 
  958.     { 
  959.         memcpy (dest, src+((y&63)<<6), 64); 
  960.         dest += 64; 
  961.     } 
  962.  
  963.     if (SCREENWIDTH&63) 
  964.     { 
  965.         memcpy (dest, src+((y&63)<<6), SCREENWIDTH&63); 
  966.         dest += (SCREENWIDTH&63); 
  967.     } 
  968.     } 
  969.     
  970.     patch = W_CacheLumpName ("brdr_t",PU_CACHE);
  971.  
  972.     for (x=0 ; x<scaledviewwidth ; x+=8)
  973.     V_DrawPatch (viewwindowx+x,viewwindowy-8,1,patch);
  974.     patch = W_CacheLumpName ("brdr_b",PU_CACHE);
  975.  
  976.     for (x=0 ; x<scaledviewwidth ; x+=8)
  977.     V_DrawPatch (viewwindowx+x,viewwindowy+viewheight,1,patch);
  978.     patch = W_CacheLumpName ("brdr_l",PU_CACHE);
  979.  
  980.     for (y=0 ; y<viewheight ; y+=8)
  981.     V_DrawPatch (viewwindowx-8,viewwindowy+y,1,patch);
  982.     patch = W_CacheLumpName ("brdr_r",PU_CACHE);
  983.  
  984.     for (y=0 ; y<viewheight ; y+=8)
  985.     V_DrawPatch (viewwindowx+scaledviewwidth,viewwindowy+y,1,patch);
  986.  
  987.  
  988.     // Draw beveled edge. 
  989.     V_DrawPatch (viewwindowx-8,
  990.          viewwindowy-8,
  991.          1,
  992.          W_CacheLumpName ("brdr_tl",PU_CACHE));
  993.     
  994.     V_DrawPatch (viewwindowx+scaledviewwidth,
  995.          viewwindowy-8,
  996.          1,
  997.          W_CacheLumpName ("brdr_tr",PU_CACHE));
  998.     
  999.     V_DrawPatch (viewwindowx-8,
  1000.          viewwindowy+viewheight,
  1001.          1,
  1002.          W_CacheLumpName ("brdr_bl",PU_CACHE));
  1003.     
  1004.     V_DrawPatch (viewwindowx+scaledviewwidth,
  1005.          viewwindowy+viewheight,
  1006.          1,
  1007.          W_CacheLumpName ("brdr_br",PU_CACHE));
  1008. } 
  1009.  
  1010.  
  1011. //
  1012. // Copy a screen buffer.
  1013. //
  1014. void
  1015. R_VideoErase
  1016. ( unsigned    ofs,
  1017.   int        count ) 
  1018. { 
  1019.   // LFB copy.
  1020.   // This might not be a good idea if memcpy
  1021.   //  is not optiomal, e.g. byte by byte on
  1022.   //  a 32bit CPU, as GNU GCC/Linux libc did
  1023.   //  at one point.
  1024.     memcpy (screens[0]+ofs, screens[1]+ofs, count); 
  1025. } 
  1026.  
  1027.  
  1028. //
  1029. // R_DrawViewBorder
  1030. // Draws the border around the view
  1031. //  for different size windows?
  1032. //
  1033. void
  1034. V_MarkRect
  1035. ( int        x,
  1036.   int        y,
  1037.   int        width,
  1038.   int        height ); 
  1039.  
  1040. void R_DrawViewBorder (void) 
  1041. { 
  1042.     int        top;
  1043.     int        side;
  1044.     int        ofs;
  1045.     int        i; 
  1046.  
  1047.     if (scaledviewwidth == SCREENWIDTH) 
  1048.     return; 
  1049.   
  1050.     top = ((SCREENHEIGHT-SBARHEIGHT)-viewheight)/2; 
  1051.     side = (SCREENWIDTH-scaledviewwidth)/2; 
  1052.  
  1053.     // copy top and one line of left side 
  1054.     R_VideoErase (0, top*SCREENWIDTH+side); 
  1055.  
  1056.     // copy one line of right side and bottom 
  1057.     ofs = (viewheight+top)*SCREENWIDTH-side; 
  1058.     R_VideoErase (ofs, top*SCREENWIDTH+side); 
  1059.  
  1060.     // copy sides using wraparound 
  1061.     ofs = top*SCREENWIDTH + SCREENWIDTH-side; 
  1062.     side <<= 1;
  1063.     
  1064.     for (i=1 ; i<viewheight ; i++) 
  1065.     { 
  1066.     R_VideoErase (ofs, side); 
  1067.     ofs += SCREENWIDTH; 
  1068.     } 
  1069.  
  1070.     // ? 
  1071.     V_MarkRect (0,0,SCREENWIDTH, SCREENHEIGHT-SBARHEIGHT); 
  1072. } 
  1073.  
  1074.  
  1075.